home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / glibmm-2.4 / glibmm / signalproxy.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-20  |  15.5 KB  |  395 lines
  1. // -*- c++ -*-
  2. /* This is a generated file, do not edit.  Generated from signalproxy.h.m4 */
  3.  
  4. #ifndef _GLIBMM_SIGNALPROXY_H
  5. #define _GLIBMM_SIGNALPROXY_H
  6.  
  7. extern "C"
  8. {
  9.   typedef void (*GCallback) (void);
  10.   typedef struct _GObject GObject;
  11. }
  12.  
  13. #include <sigc++/sigc++.h>
  14. #include <glibmm/signalproxy_connectionnode.h>
  15.  
  16.  
  17. namespace Glib
  18. {
  19.  
  20. // Forward declarations
  21. class ObjectBase;
  22.  
  23. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  24.  
  25. struct SignalProxyInfo
  26. {
  27.   const char* signal_name;
  28.   GCallback   callback;
  29.   GCallback   notify_callback;
  30. };
  31.  
  32. #endif //DOXYGEN_SHOULD_SKIP_THIS
  33.  
  34. // This base class is used by SignalProxyNormal and SignalProxyProperty.
  35. class SignalProxyBase
  36. {
  37. public:
  38.   SignalProxyBase(Glib::ObjectBase* obj);
  39.  
  40. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  41.   static inline sigc::slot_base* data_to_slot(void* data)
  42.   {
  43.     SignalProxyConnectionNode *const pConnectionNode = static_cast<SignalProxyConnectionNode*>(data);
  44.  
  45.     // Return 0 if the connection is blocked.
  46.     return (!pConnectionNode->slot_.blocked()) ? &pConnectionNode->slot_ : 0;
  47.   }
  48. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  49.  
  50. protected:
  51.   ObjectBase* obj_;
  52.  
  53. private:
  54.   SignalProxyBase& operator=(const SignalProxyBase&); // not implemented
  55. };
  56.  
  57.  
  58. // shared portion of a Signal
  59. /** The SignalProxy provides an API similar to sigc::signal that can be used to
  60.  * connect sigc::slots to glib signals.
  61.  *
  62.  * This holds the name of the glib signal and the object
  63.  * which might emit it. Actually, proxies are controlled by
  64.  * the template derivatives, which serve as gatekeepers for the
  65.  * types allowed on a particular signal.
  66.  *
  67.  */
  68. class SignalProxyNormal : public SignalProxyBase
  69. {
  70. public:
  71.   ~SignalProxyNormal();
  72.  
  73.   /// stops the current signal emmision (not in libsigc++)
  74.   void emission_stop();
  75.  
  76. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  77.   // This callback for SignalProxy0<void>
  78.   // is defined here to avoid code duplication.
  79.   static void slot0_void_callback(GObject*, void* data);
  80. #endif
  81.  
  82. protected:
  83.  
  84.   /** Create a proxy for a signal that can be emitted by @a obj.
  85.    * @param obj The object that can emit the signal.
  86.    * @param info Information about the signal, including its name, and the C callbacks that should be called by glib.
  87.    */
  88.   SignalProxyNormal(Glib::ObjectBase* obj, const SignalProxyInfo* info);
  89.  
  90.   /** Connects a signal to a generic signal handler. This is called by connect() in derived SignalProxy classes.
  91.    *
  92.    * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  93.    * @param after Whether this signal handler should be called before or after the default signal handler.
  94.    */
  95.   sigc::slot_base& connect_(const sigc::slot_base& slot, bool after);
  96.  
  97.   /** Connects a signal to a signal handler without a return value.
  98.    * This is called by connect() in derived SignalProxy classes.
  99.    *
  100.    * By default, the signal handler will be called before the default signal handler,
  101.    * in which case any return value would be replaced anyway by that of the later signal handler.
  102.    *
  103.    * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  104.    * @param after Whether this signal handler should be called before or after the default signal handler.
  105.    */
  106.   sigc::slot_base& connect_notify_(const sigc::slot_base& slot, bool after);
  107.  
  108. private:
  109.   const SignalProxyInfo* info_;
  110.  
  111.   //TODO: We could maybe replace both connect_ and connect_notify_ with this in future, because they don't do anything extra.
  112.   /** This is called by connect_ and connect_impl_.
  113.    */
  114.   sigc::slot_base& connect_impl_(GCallback callback, const sigc::slot_base& slot, bool after);
  115.  
  116.   // no copy assignment
  117.   SignalProxyNormal& operator=(const SignalProxyNormal&);
  118. };
  119.  
  120.  
  121.  
  122.  
  123.  
  124. /**** Glib::SignalProxy0 ***************************************************/
  125.  
  126. /** Proxy for signals with 0 arguments.
  127.  * Use the connect() method, with sigc::mem_fun() or sigc::ptr_fun() to connect signals to signal handlers.
  128.  */
  129. template <class R>
  130. class SignalProxy0 : public SignalProxyNormal
  131. {
  132. public:
  133.   typedef sigc::slot<R>    SlotType;
  134.   typedef sigc::slot<void> VoidSlotType;
  135.  
  136.   SignalProxy0(ObjectBase* obj, const SignalProxyInfo* info)
  137.     : SignalProxyNormal(obj, info) {}
  138.  
  139.   /** Connects a signal to a signal handler.
  140.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  141.    *
  142.    * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  143.    * @param after Whether this signal handler should be called before or after the default signal handler.
  144.    */
  145.   sigc::connection connect(const SlotType& slot, bool after = true)
  146.     { return sigc::connection(connect_(slot, after)); }
  147.  
  148.   /** Connects a signal to a signal handler without a return value.
  149.    * By default, the signal handler will be called before the default signal handler,
  150.    * in which case any return value would be replaced anyway by that of the later signal handler.
  151.    *
  152.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  153.    *
  154.    * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  155.    * @param after Whether this signal handler should be called before or after the default signal handler.
  156.    */
  157.   sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
  158.     { return sigc::connection(connect_notify_(slot, after)); }
  159. };
  160.  
  161.  
  162. /**** Glib::SignalProxy1 ***************************************************/
  163.  
  164. /** Proxy for signals with 1 arguments.
  165.  * Use the connect() method, with sigc::mem_fun() or sigc::ptr_fun() to connect signals to signal handlers.
  166.  */
  167. template <class R,class P1>
  168. class SignalProxy1 : public SignalProxyNormal
  169. {
  170. public:
  171.   typedef sigc::slot<R,P1>    SlotType;
  172.   typedef sigc::slot<void,P1> VoidSlotType;
  173.  
  174.   SignalProxy1(ObjectBase* obj, const SignalProxyInfo* info)
  175.     : SignalProxyNormal(obj, info) {}
  176.  
  177.   /** Connects a signal to a signal handler.
  178.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  179.    *
  180.    * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  181.    * @param after Whether this signal handler should be called before or after the default signal handler.
  182.    */
  183.   sigc::connection connect(const SlotType& slot, bool after = true)
  184.     { return sigc::connection(connect_(slot, after)); }
  185.  
  186.   /** Connects a signal to a signal handler without a return value.
  187.    * By default, the signal handler will be called before the default signal handler,
  188.    * in which case any return value would be replaced anyway by that of the later signal handler.
  189.    *
  190.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  191.    *
  192.    * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  193.    * @param after Whether this signal handler should be called before or after the default signal handler.
  194.    */
  195.   sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
  196.     { return sigc::connection(connect_notify_(slot, after)); }
  197. };
  198.  
  199.  
  200. /**** Glib::SignalProxy2 ***************************************************/
  201.  
  202. /** Proxy for signals with 2 arguments.
  203.  * Use the connect() method, with sigc::mem_fun() or sigc::ptr_fun() to connect signals to signal handlers.
  204.  */
  205. template <class R,class P1,class P2>
  206. class SignalProxy2 : public SignalProxyNormal
  207. {
  208. public:
  209.   typedef sigc::slot<R,P1,P2>    SlotType;
  210.   typedef sigc::slot<void,P1,P2> VoidSlotType;
  211.  
  212.   SignalProxy2(ObjectBase* obj, const SignalProxyInfo* info)
  213.     : SignalProxyNormal(obj, info) {}
  214.  
  215.   /** Connects a signal to a signal handler.
  216.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  217.    *
  218.    * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  219.    * @param after Whether this signal handler should be called before or after the default signal handler.
  220.    */
  221.   sigc::connection connect(const SlotType& slot, bool after = true)
  222.     { return sigc::connection(connect_(slot, after)); }
  223.  
  224.   /** Connects a signal to a signal handler without a return value.
  225.    * By default, the signal handler will be called before the default signal handler,
  226.    * in which case any return value would be replaced anyway by that of the later signal handler.
  227.    *
  228.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  229.    *
  230.    * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  231.    * @param after Whether this signal handler should be called before or after the default signal handler.
  232.    */
  233.   sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
  234.     { return sigc::connection(connect_notify_(slot, after)); }
  235. };
  236.  
  237.  
  238. /**** Glib::SignalProxy3 ***************************************************/
  239.  
  240. /** Proxy for signals with 3 arguments.
  241.  * Use the connect() method, with sigc::mem_fun() or sigc::ptr_fun() to connect signals to signal handlers.
  242.  */
  243. template <class R,class P1,class P2,class P3>
  244. class SignalProxy3 : public SignalProxyNormal
  245. {
  246. public:
  247.   typedef sigc::slot<R,P1,P2,P3>    SlotType;
  248.   typedef sigc::slot<void,P1,P2,P3> VoidSlotType;
  249.  
  250.   SignalProxy3(ObjectBase* obj, const SignalProxyInfo* info)
  251.     : SignalProxyNormal(obj, info) {}
  252.  
  253.   /** Connects a signal to a signal handler.
  254.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  255.    *
  256.    * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  257.    * @param after Whether this signal handler should be called before or after the default signal handler.
  258.    */
  259.   sigc::connection connect(const SlotType& slot, bool after = true)
  260.     { return sigc::connection(connect_(slot, after)); }
  261.  
  262.   /** Connects a signal to a signal handler without a return value.
  263.    * By default, the signal handler will be called before the default signal handler,
  264.    * in which case any return value would be replaced anyway by that of the later signal handler.
  265.    *
  266.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  267.    *
  268.    * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  269.    * @param after Whether this signal handler should be called before or after the default signal handler.
  270.    */
  271.   sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
  272.     { return sigc::connection(connect_notify_(slot, after)); }
  273. };
  274.  
  275.  
  276. /**** Glib::SignalProxy4 ***************************************************/
  277.  
  278. /** Proxy for signals with 4 arguments.
  279.  * Use the connect() method, with sigc::mem_fun() or sigc::ptr_fun() to connect signals to signal handlers.
  280.  */
  281. template <class R,class P1,class P2,class P3,class P4>
  282. class SignalProxy4 : public SignalProxyNormal
  283. {
  284. public:
  285.   typedef sigc::slot<R,P1,P2,P3,P4>    SlotType;
  286.   typedef sigc::slot<void,P1,P2,P3,P4> VoidSlotType;
  287.  
  288.   SignalProxy4(ObjectBase* obj, const SignalProxyInfo* info)
  289.     : SignalProxyNormal(obj, info) {}
  290.  
  291.   /** Connects a signal to a signal handler.
  292.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  293.    *
  294.    * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  295.    * @param after Whether this signal handler should be called before or after the default signal handler.
  296.    */
  297.   sigc::connection connect(const SlotType& slot, bool after = true)
  298.     { return sigc::connection(connect_(slot, after)); }
  299.  
  300.   /** Connects a signal to a signal handler without a return value.
  301.    * By default, the signal handler will be called before the default signal handler,
  302.    * in which case any return value would be replaced anyway by that of the later signal handler.
  303.    *
  304.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  305.    *
  306.    * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  307.    * @param after Whether this signal handler should be called before or after the default signal handler.
  308.    */
  309.   sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
  310.     { return sigc::connection(connect_notify_(slot, after)); }
  311. };
  312.  
  313.  
  314. /**** Glib::SignalProxy5 ***************************************************/
  315.  
  316. /** Proxy for signals with 5 arguments.
  317.  * Use the connect() method, with sigc::mem_fun() or sigc::ptr_fun() to connect signals to signal handlers.
  318.  */
  319. template <class R,class P1,class P2,class P3,class P4,class P5>
  320. class SignalProxy5 : public SignalProxyNormal
  321. {
  322. public:
  323.   typedef sigc::slot<R,P1,P2,P3,P4,P5>    SlotType;
  324.   typedef sigc::slot<void,P1,P2,P3,P4,P5> VoidSlotType;
  325.  
  326.   SignalProxy5(ObjectBase* obj, const SignalProxyInfo* info)
  327.     : SignalProxyNormal(obj, info) {}
  328.  
  329.   /** Connects a signal to a signal handler.
  330.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  331.    *
  332.    * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  333.    * @param after Whether this signal handler should be called before or after the default signal handler.
  334.    */
  335.   sigc::connection connect(const SlotType& slot, bool after = true)
  336.     { return sigc::connection(connect_(slot, after)); }
  337.  
  338.   /** Connects a signal to a signal handler without a return value.
  339.    * By default, the signal handler will be called before the default signal handler,
  340.    * in which case any return value would be replaced anyway by that of the later signal handler.
  341.    *
  342.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  343.    *
  344.    * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  345.    * @param after Whether this signal handler should be called before or after the default signal handler.
  346.    */
  347.   sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
  348.     { return sigc::connection(connect_notify_(slot, after)); }
  349. };
  350.  
  351.  
  352. /**** Glib::SignalProxy6 ***************************************************/
  353.  
  354. /** Proxy for signals with 6 arguments.
  355.  * Use the connect() method, with sigc::mem_fun() or sigc::ptr_fun() to connect signals to signal handlers.
  356.  */
  357. template <class R,class P1,class P2,class P3,class P4,class P5,class P6>
  358. class SignalProxy6 : public SignalProxyNormal
  359. {
  360. public:
  361.   typedef sigc::slot<R,P1,P2,P3,P4,P5,P6>    SlotType;
  362.   typedef sigc::slot<void,P1,P2,P3,P4,P5,P6> VoidSlotType;
  363.  
  364.   SignalProxy6(ObjectBase* obj, const SignalProxyInfo* info)
  365.     : SignalProxyNormal(obj, info) {}
  366.  
  367.   /** Connects a signal to a signal handler.
  368.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  369.    *
  370.    * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  371.    * @param after Whether this signal handler should be called before or after the default signal handler.
  372.    */
  373.   sigc::connection connect(const SlotType& slot, bool after = true)
  374.     { return sigc::connection(connect_(slot, after)); }
  375.  
  376.   /** Connects a signal to a signal handler without a return value.
  377.    * By default, the signal handler will be called before the default signal handler,
  378.    * in which case any return value would be replaced anyway by that of the later signal handler.
  379.    *
  380.    * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
  381.    *
  382.    * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
  383.    * @param after Whether this signal handler should be called before or after the default signal handler.
  384.    */
  385.   sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
  386.     { return sigc::connection(connect_notify_(slot, after)); }
  387. };
  388.  
  389.  
  390. } // namespace Glib
  391.  
  392.  
  393. #endif /* _GLIBMM_SIGNALPROXY_H */
  394.  
  395.